from fastapi import APIRouter, HTTPException, Body, Query, Request
from typing import Dict, Optional
from app.services.user_service import user_service
from app.utils.error_handling import ErrorHandler, BadRequestError
import logging

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# 创建路由器
router = APIRouter(prefix="/api/v1/users")


@router.post("/register")
async def register_user(
    shopify_domain: str = Body(..., description="Shopify店铺域名"),
    access_token: Optional[str] = Body(None, description="Shopify访问令牌（可选）")
) -> Dict:
    """
    用户注册接口
    
    当用户在Shopify应用商店安装我们的应用后，首次点击login按钮时调用此接口。
    会将用户的shopify_domain写入数据库，并在提供了access_token时获取店铺其他信息。
    
    Args:
        shopify_domain: Shopify店铺域名
        access_token: Shopify访问令牌（可选）
        
    Returns:
        Dict: 注册结果
    """
    try:
        # 参数验证
        if not shopify_domain or len(shopify_domain.strip()) == 0:
            error = BadRequestError("Shopify域名不能为空")
            return ErrorHandler.handle_api_error(error, shopify_domain)
        
        # 调用服务层进行注册
        result = user_service.register_user(shopify_domain, access_token)
        
        # 根据结果返回响应
        if result["success"]:
            return {
                "is_success": 1,
                "message": result["message"],
                "data": {
                    "user_id": result["user_id"],
                    "shopify_domain": result["shopify_domain"],
                    "user_info": result["user_info"]
                }
            }
        else:
            error = BadRequestError(result["message"])
            return ErrorHandler.handle_api_error(error, shopify_domain)
            
    except Exception as e:
        logging.error(f"用户注册接口异常: {str(e)}")
        return ErrorHandler.handle_generic_exception(e, shopify_domain)


@router.post("/sync")
async def sync_user_info(
    shopify_domain: str = Body(..., description="Shopify店铺域名"),
    access_token: str = Body(..., description="Shopify访问令牌")
) -> Dict:
    """
    同步用户信息接口
    
    根据shopify_domain和access_token，从Shopify获取用户的完整信息并更新到数据库。
    适用于用户已注册但需要更新信息的场景。
    
    Args:
        shopify_domain: Shopify店铺域名
        access_token: Shopify访问令牌（必需）
        
    Returns:
        Dict: 同步结果
    """
    try:
        # 参数验证
        if not shopify_domain or len(shopify_domain.strip()) == 0:
            error = BadRequestError("Shopify域名不能为空")
            return ErrorHandler.handle_api_error(error, shopify_domain)
        
        if not access_token or len(access_token.strip()) == 0:
            error = BadRequestError("访问令牌不能为空")
            return ErrorHandler.handle_api_error(error, shopify_domain)
        
        # 调用服务层进行同步
        result = user_service.update_user_by_domain(shopify_domain, access_token)
        
        # 根据结果返回响应
        if result["success"]:
            return {
                "is_success": 1,
                "message": result["message"],
                "data": {
                    "shopify_domain": result["shopify_domain"],
                    "user_info": result["user_info"]
                }
            }
        else:
            error = BadRequestError(result["message"])
            return ErrorHandler.handle_api_error(error, shopify_domain)
            
    except Exception as e:
        logging.error(f"同步用户信息接口异常: {str(e)}")
        return ErrorHandler.handle_generic_exception(e, shopify_domain)


@router.post("/register_and_sync")
async def register_and_sync_user(
    shopify_domain: str = Body(..., description="Shopify店铺域名"),
    access_token: str = Body(..., description="Shopify访问令牌")
) -> Dict:
    """
    注册并同步用户信息接口
    
    统一接口：如果用户不存在则注册，如果存在则更新信息。
    会从Shopify获取完整的用户信息并写入数据库。
    
    Args:
        shopify_domain: Shopify店铺域名
        access_token: Shopify访问令牌（必需）
        
    Returns:
        Dict: 操作结果
    """
    try:
        # 参数验证
        if not shopify_domain or len(shopify_domain.strip()) == 0:
            error = BadRequestError("Shopify域名不能为空")
            return ErrorHandler.handle_api_error(error, shopify_domain)
        
        if not access_token or len(access_token.strip()) == 0:
            error = BadRequestError("访问令牌不能为空")
            return ErrorHandler.handle_api_error(error, shopify_domain)
        
        # 调用服务层进行注册并同步
        result = user_service.register_and_sync_user(shopify_domain, access_token)
        
        # 根据结果返回响应
        if result["success"]:
            return {
                "is_success": 1,
                "message": result["message"],
                "data": {
                    "shopify_domain": result["shopify_domain"],
                    "user_info": result["user_info"]
                }
            }
        else:
            error = BadRequestError(result["message"])
            return ErrorHandler.handle_api_error(error, shopify_domain)
            
    except Exception as e:
        logging.error(f"注册并同步用户信息接口异常: {str(e)}")
        return ErrorHandler.handle_generic_exception(e, shopify_domain)


@router.post("")
async def handle_user_registration(
    request: Request,
    shopify_domain: str = Body(..., description="Shopify店铺域名"),
    access_token: str = Body(..., description="Shopify访问令牌")
) -> Dict:
    """
    用户注册与信息同步统一接口
    
    这是APP登录界面的主要接口，处理完整的用户注册和信息同步流程：
    1. 验证用户提供的shopify_domain和access_token
    2. 检查用户是否已存在于系统中
    3. 获取Shopify店铺的完整信息
    4. 根据用户存在状态，创建新用户或更新现有用户信息
    5. 返回处理结果和完整的用户信息
    
    Args:
        request: FastAPI请求对象，用于获取设备信息
        shopify_domain: Shopify店铺域名
        access_token: Shopify访问令牌
        
    Returns:
        Dict: 处理结果和用户信息
    """
    try:
        # 参数验证
        if not shopify_domain or len(shopify_domain.strip()) == 0:
            error = BadRequestError("Shopify域名不能为空")
            return ErrorHandler.handle_api_error(error, shopify_domain)
        
        if not access_token or len(access_token.strip()) == 0:
            error = BadRequestError("访问令牌不能为空")
            return ErrorHandler.handle_api_error(error, shopify_domain)
        
        # 收集设备信息
        device_info = {
            "user_agent": request.headers.get("User-Agent", ""),
            "ip_address": request.client.host if request.client else "",
            "accept_language": request.headers.get("Accept-Language", ""),
            "referer": request.headers.get("Referer", "")
        }
        
        logging.info(f"处理用户注册请求: {shopify_domain}, 设备信息: {device_info}")
        
        # 调用服务层处理用户注册和信息同步
        result = user_service.process_user(shopify_domain, access_token, device_info)
        
        # 根据结果返回响应
        if result["success"]:
            response_data = {
                "is_success": 1,
                "message": result["message"],
                "data": {
                    "shopify_domain": result["shopify_domain"],
                    "user_info": result["user_info"],
                    "complete_shop_info": result.get("complete_shop_info", {})
                }
            }
            
            # 如果有user_id（新用户），也包含在响应中
            if "user_id" in result:
                response_data["data"]["user_id"] = result["user_id"]
                
            return response_data
        else:
            error = BadRequestError(result["message"])
            return ErrorHandler.handle_api_error(error, shopify_domain)
            
    except Exception as e:
        logging.error(f"用户注册统一接口异常: {str(e)}")
        return ErrorHandler.handle_generic_exception(e, shopify_domain)


@router.get("/info")
async def get_user_info(
    shopify_domain: str = Query(..., description="Shopify店铺域名")
) -> Dict:
    """
    获取用户信息接口
    
    根据shopify_domain查询用户信息。
    
    Args:
        shopify_domain: Shopify店铺域名
        
    Returns:
        Dict: 用户信息
    """
    try:
        # 参数验证
        if not shopify_domain or len(shopify_domain.strip()) == 0:
            error = BadRequestError("Shopify域名不能为空")
            return ErrorHandler.handle_api_error(error, shopify_domain)
        
        # 调用服务层获取用户信息
        result = user_service.get_user_info(shopify_domain)
        
        # 根据结果返回响应
        if result["success"]:
            return {
                "is_success": 1,
                "message": result["message"],
                "data": {
                    "shopify_domain": result["shopify_domain"],
                    "user_info": result["user_info"]
                }
            }
        else:
            error = BadRequestError(result["message"])
            return ErrorHandler.handle_api_error(error, shopify_domain)
            
    except Exception as e:
        logging.error(f"获取用户信息接口异常: {str(e)}")
        return ErrorHandler.handle_generic_exception(e, shopify_domain)